import {FormConfig, FormHookResult, FormItemBaseConfig, FormItemConfig, FormRule} from '../types';

/**
 * 生成表单项验证规则
 * @param item 表单项
 * @param config 全局配置
 */
function generateItemRule(item: FormItemBaseConfig, config?: FormConfig): FormRule[] {
  const rules: FormRule[] = [];

  // 处理必填验证
  if (item.required) {
    const message = `请${item.type === 'select' ? '选择' : '输入'}${item.label || ''}`;
    rules.push({
      required: true,
      message,
      trigger: ['blur', 'change']
    });
  }

  // 全局验证规则
  if (config?.rules && config.rules[item.prop]) {
    const globalRules = config.rules[item.prop];
    if (Array.isArray(globalRules)) {
      rules.push(...globalRules);
    } else {
      rules.push(globalRules);
    }
  }

  // 表单项验证规则
  if (item.rules) {
    if (Array.isArray(item.rules)) {
      rules.push(...item.rules);
    } else {
      rules.push(item.rules);
    }
  }

  return rules;
}

/**
 * 生成表单规则
 * @param itemsList 表单项列表
 * @param config 全局配置
 */
function generateFormRules(itemsList: FormItemBaseConfig[][], config?: FormConfig): Record<string, FormRule[]> {
  const formRules: Record<string, FormRule[]> = {};

  itemsList.forEach(items => {
    items.forEach(item => {
      const rules = generateItemRule(item, config);
      if (rules.length > 0) {
        formRules[item.prop] = rules;
      }
    });
  });

  return formRules;
}

/**
 * 处理表单项
 * @param items 表单项配置
 * @param config 全局配置
 */
function processItems(items: FormItemBaseConfig[], config?: FormConfig): FormItemConfig[] {
  return items.map(item => {
    // 复制item，避免修改原始数据
    const newItem: FormItemConfig = {...item};

    // 默认类型为custom
    if (!newItem.type) {
      newItem.type = 'custom';
    }

    // 合并全局组件属性
    if (config?.componentProps) {
      newItem.componentProps = {
        ...(config.componentProps || {}),
        ...(newItem.componentProps || {})
      };
    }

    // 合并全局表单项属性
    if (config?.itemProps) {
      newItem.itemProps = {
        ...(config.itemProps || {}),
        ...(newItem.itemProps || {})
      };
    }

    // 默认显示
    newItem.show = true;

    return newItem;
  });
}

/**
 * 标准化表单项配置
 * 支持以下格式：
 * 1. 单层数组: [{ prop: 'name', ... }, { prop: 'age', ... }]
 * 2. 双层数组: [[{ prop: 'name', ... }], [{ prop: 'age', ... }]]
 *
 * @param items 表单项配置（多种格式）
 */
function normalizeItemsList(items: FormItemBaseConfig[] | FormItemBaseConfig[][]): FormItemBaseConfig[][] {
  if (!items) {
    return [[]];
  }

  // 空数组
  if (items.length === 0) {
    return [[]];
  }

  // 判断是否为二维数组
  if (Array.isArray(items[0])) {
    return items as FormItemBaseConfig[][];
  }

  // 一维数组: 转为 [[{}, {}]]
  return [items as FormItemBaseConfig[]];
}

/**
 * 表单工具
 * @param items 表单项配置，支持单层数组和双层数组格式
 * @param config 全局配置
 */
export function useForm(
  items: FormItemBaseConfig[] | FormItemBaseConfig[][],
  config?: FormConfig
): FormHookResult {
  // 处理表单配置
  const formConfig: FormConfig = config || {};

  // 标准化表单项配置
  const normalizedItemsList = normalizeItemsList(items);

  // 处理表单项
  const itemList = normalizedItemsList.map(items => processItems(items, formConfig));

  // 生成表单规则
  const formRules = generateFormRules(normalizedItemsList, formConfig);

  // 表单项 - 便于单层数组直接使用
  const formItems = itemList[0];

  return {
    itemList,    // 保持二维数组兼容性
    formItems,   // 提供更直观的单层数组访问
    formRules,
    formConfig
  };
}
